// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#[allow(unused_imports)]
use super::*;

impl std::fmt::Debug for super::AutonomousDatabase {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutonomousDatabase");
        debug_struct.field("name", &self.name);
        debug_struct.field("database", &self.database);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("entitlement_id", &self.entitlement_id);
        debug_struct.field("admin_password", &self.admin_password);
        debug_struct.field("properties", &self.properties);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("network", &self.network);
        debug_struct.field("cidr", &self.cidr);
        debug_struct.field("odb_network", &self.odb_network);
        debug_struct.field("odb_subnet", &self.odb_subnet);
        debug_struct.field("source_config", &self.source_config);
        debug_struct.field("peer_autonomous_databases", &self.peer_autonomous_databases);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field(
            "disaster_recovery_supported_locations",
            &self.disaster_recovery_supported_locations,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::SourceConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SourceConfig");
        debug_struct.field("autonomous_database", &self.autonomous_database);
        debug_struct.field(
            "automatic_backups_replication_enabled",
            &self.automatic_backups_replication_enabled,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AutonomousDatabaseProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutonomousDatabaseProperties");
        debug_struct.field("ocid", &self.ocid);
        debug_struct.field("compute_count", &self.compute_count);
        debug_struct.field("cpu_core_count", &self.cpu_core_count);
        debug_struct.field("data_storage_size_tb", &self.data_storage_size_tb);
        debug_struct.field("data_storage_size_gb", &self.data_storage_size_gb);
        debug_struct.field("db_workload", &self.db_workload);
        debug_struct.field("db_edition", &self.db_edition);
        debug_struct.field("character_set", &self.character_set);
        debug_struct.field("n_character_set", &self.n_character_set);
        debug_struct.field("private_endpoint_ip", &self.private_endpoint_ip);
        debug_struct.field("private_endpoint_label", &self.private_endpoint_label);
        debug_struct.field("db_version", &self.db_version);
        debug_struct.field("is_auto_scaling_enabled", &self.is_auto_scaling_enabled);
        debug_struct.field(
            "is_storage_auto_scaling_enabled",
            &self.is_storage_auto_scaling_enabled,
        );
        debug_struct.field("license_type", &self.license_type);
        debug_struct.field("customer_contacts", &self.customer_contacts);
        debug_struct.field("secret_id", &self.secret_id);
        debug_struct.field("vault_id", &self.vault_id);
        debug_struct.field("maintenance_schedule_type", &self.maintenance_schedule_type);
        debug_struct.field("mtls_connection_required", &self.mtls_connection_required);
        debug_struct.field(
            "backup_retention_period_days",
            &self.backup_retention_period_days,
        );
        debug_struct.field(
            "actual_used_data_storage_size_tb",
            &self.actual_used_data_storage_size_tb,
        );
        debug_struct.field("allocated_storage_size_tb", &self.allocated_storage_size_tb);
        debug_struct.field("apex_details", &self.apex_details);
        debug_struct.field(
            "are_primary_allowlisted_ips_used",
            &self.are_primary_allowlisted_ips_used,
        );
        debug_struct.field("lifecycle_details", &self.lifecycle_details);
        debug_struct.field("state", &self.state);
        debug_struct.field(
            "autonomous_container_database_id",
            &self.autonomous_container_database_id,
        );
        debug_struct.field(
            "available_upgrade_versions",
            &self.available_upgrade_versions,
        );
        debug_struct.field("connection_strings", &self.connection_strings);
        debug_struct.field("connection_urls", &self.connection_urls);
        debug_struct.field(
            "failed_data_recovery_duration",
            &self.failed_data_recovery_duration,
        );
        debug_struct.field("memory_table_gbs", &self.memory_table_gbs);
        debug_struct.field(
            "is_local_data_guard_enabled",
            &self.is_local_data_guard_enabled,
        );
        debug_struct.field(
            "local_adg_auto_failover_max_data_loss_limit",
            &self.local_adg_auto_failover_max_data_loss_limit,
        );
        debug_struct.field("local_standby_db", &self.local_standby_db);
        debug_struct.field(
            "memory_per_oracle_compute_unit_gbs",
            &self.memory_per_oracle_compute_unit_gbs,
        );
        debug_struct.field(
            "local_disaster_recovery_type",
            &self.local_disaster_recovery_type,
        );
        debug_struct.field("data_safe_state", &self.data_safe_state);
        debug_struct.field("database_management_state", &self.database_management_state);
        debug_struct.field("open_mode", &self.open_mode);
        debug_struct.field("operations_insights_state", &self.operations_insights_state);
        debug_struct.field("peer_db_ids", &self.peer_db_ids);
        debug_struct.field("permission_level", &self.permission_level);
        debug_struct.field("private_endpoint", &self.private_endpoint);
        debug_struct.field("refreshable_mode", &self.refreshable_mode);
        debug_struct.field("refreshable_state", &self.refreshable_state);
        debug_struct.field("role", &self.role);
        debug_struct.field(
            "scheduled_operation_details",
            &self.scheduled_operation_details,
        );
        debug_struct.field("sql_web_developer_url", &self.sql_web_developer_url);
        debug_struct.field("supported_clone_regions", &self.supported_clone_regions);
        debug_struct.field(
            "used_data_storage_size_tbs",
            &self.used_data_storage_size_tbs,
        );
        debug_struct.field("oci_url", &self.oci_url);
        debug_struct.field(
            "total_auto_backup_storage_size_gbs",
            &self.total_auto_backup_storage_size_gbs,
        );
        debug_struct.field(
            "next_long_term_backup_time",
            &self.next_long_term_backup_time,
        );
        debug_struct.field(
            "data_guard_role_changed_time",
            &self.data_guard_role_changed_time,
        );
        debug_struct.field(
            "disaster_recovery_role_changed_time",
            &self.disaster_recovery_role_changed_time,
        );
        debug_struct.field("maintenance_begin_time", &self.maintenance_begin_time);
        debug_struct.field("maintenance_end_time", &self.maintenance_end_time);
        debug_struct.field("allowlisted_ips", &self.allowlisted_ips);
        debug_struct.field("encryption_key", &self.encryption_key);
        debug_struct.field(
            "encryption_key_history_entries",
            &self.encryption_key_history_entries,
        );
        debug_struct.field("service_agent_email", &self.service_agent_email);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::EncryptionKeyHistoryEntry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EncryptionKeyHistoryEntry");
        debug_struct.field("encryption_key", &self.encryption_key);
        debug_struct.field("activation_time", &self.activation_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::EncryptionKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EncryptionKey");
        debug_struct.field("provider", &self.provider);
        debug_struct.field("kms_key", &self.kms_key);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AutonomousDatabaseApex {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutonomousDatabaseApex");
        debug_struct.field("apex_version", &self.apex_version);
        debug_struct.field("ords_version", &self.ords_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AutonomousDatabaseConnectionStrings {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutonomousDatabaseConnectionStrings");
        debug_struct.field("all_connection_strings", &self.all_connection_strings);
        debug_struct.field("dedicated", &self.dedicated);
        debug_struct.field("high", &self.high);
        debug_struct.field("low", &self.low);
        debug_struct.field("medium", &self.medium);
        debug_struct.field("profiles", &self.profiles);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DatabaseConnectionStringProfile {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DatabaseConnectionStringProfile");
        debug_struct.field("consumer_group", &self.consumer_group);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("host_format", &self.host_format);
        debug_struct.field("is_regional", &self.is_regional);
        debug_struct.field("protocol", &self.protocol);
        debug_struct.field("session_mode", &self.session_mode);
        debug_struct.field("syntax_format", &self.syntax_format);
        debug_struct.field("tls_authentication", &self.tls_authentication);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AllConnectionStrings {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AllConnectionStrings");
        debug_struct.field("high", &self.high);
        debug_struct.field("low", &self.low);
        debug_struct.field("medium", &self.medium);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AutonomousDatabaseConnectionUrls {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutonomousDatabaseConnectionUrls");
        debug_struct.field("apex_uri", &self.apex_uri);
        debug_struct.field("database_transforms_uri", &self.database_transforms_uri);
        debug_struct.field("graph_studio_uri", &self.graph_studio_uri);
        debug_struct.field(
            "machine_learning_notebook_uri",
            &self.machine_learning_notebook_uri,
        );
        debug_struct.field(
            "machine_learning_user_management_uri",
            &self.machine_learning_user_management_uri,
        );
        debug_struct.field("mongo_db_uri", &self.mongo_db_uri);
        debug_struct.field("ords_uri", &self.ords_uri);
        debug_struct.field("sql_dev_web_uri", &self.sql_dev_web_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AutonomousDatabaseStandbySummary {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutonomousDatabaseStandbySummary");
        debug_struct.field("lag_time_duration", &self.lag_time_duration);
        debug_struct.field("lifecycle_details", &self.lifecycle_details);
        debug_struct.field("state", &self.state);
        debug_struct.field(
            "data_guard_role_changed_time",
            &self.data_guard_role_changed_time,
        );
        debug_struct.field(
            "disaster_recovery_role_changed_time",
            &self.disaster_recovery_role_changed_time,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ScheduledOperationDetails {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ScheduledOperationDetails");
        debug_struct.field("day_of_week", &self.day_of_week);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("stop_time", &self.stop_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AutonomousDatabaseCharacterSet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutonomousDatabaseCharacterSet");
        debug_struct.field("name", &self.name);
        debug_struct.field("character_set_type", &self.character_set_type);
        debug_struct.field("character_set", &self.character_set);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AutonomousDatabaseBackup {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutonomousDatabaseBackup");
        debug_struct.field("name", &self.name);
        debug_struct.field("autonomous_database", &self.autonomous_database);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("properties", &self.properties);
        debug_struct.field("labels", &self.labels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AutonomousDatabaseBackupProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutonomousDatabaseBackupProperties");
        debug_struct.field("ocid", &self.ocid);
        debug_struct.field("retention_period_days", &self.retention_period_days);
        debug_struct.field("compartment_id", &self.compartment_id);
        debug_struct.field("database_size_tb", &self.database_size_tb);
        debug_struct.field("db_version", &self.db_version);
        debug_struct.field("is_long_term_backup", &self.is_long_term_backup);
        debug_struct.field("is_automatic_backup", &self.is_automatic_backup);
        debug_struct.field("is_restorable", &self.is_restorable);
        debug_struct.field("key_store_id", &self.key_store_id);
        debug_struct.field("key_store_wallet", &self.key_store_wallet);
        debug_struct.field("kms_key_id", &self.kms_key_id);
        debug_struct.field("kms_key_version_id", &self.kms_key_version_id);
        debug_struct.field("lifecycle_details", &self.lifecycle_details);
        debug_struct.field("lifecycle_state", &self.lifecycle_state);
        debug_struct.field("size_tb", &self.size_tb);
        debug_struct.field("available_till_time", &self.available_till_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("vault_id", &self.vault_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AutonomousDbVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutonomousDbVersion");
        debug_struct.field("name", &self.name);
        debug_struct.field("version", &self.version);
        debug_struct.field("db_workload", &self.db_workload);
        debug_struct.field("workload_uri", &self.workload_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CustomerContact {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CustomerContact");
        debug_struct.field("email", &self.email);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::IdentityConnector {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IdentityConnector");
        debug_struct.field("service_agent_email", &self.service_agent_email);
        debug_struct.field("connection_state", &self.connection_state);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DataCollectionOptionsCommon {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataCollectionOptionsCommon");
        debug_struct.field(
            "is_diagnostics_events_enabled",
            &self.is_diagnostics_events_enabled,
        );
        debug_struct.field(
            "is_health_monitoring_enabled",
            &self.is_health_monitoring_enabled,
        );
        debug_struct.field("is_incident_logs_enabled", &self.is_incident_logs_enabled);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Database {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Database");
        debug_struct.field("name", &self.name);
        debug_struct.field("db_name", &self.db_name);
        debug_struct.field("db_unique_name", &self.db_unique_name);
        debug_struct.field("admin_password", &self.admin_password);
        debug_struct.field("tde_wallet_password", &self.tde_wallet_password);
        debug_struct.field("character_set", &self.character_set);
        debug_struct.field("ncharacter_set", &self.ncharacter_set);
        debug_struct.field("oci_url", &self.oci_url);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("properties", &self.properties);
        debug_struct.field("database_id", &self.database_id);
        debug_struct.field("db_home_name", &self.db_home_name);
        debug_struct.field("gcp_oracle_zone", &self.gcp_oracle_zone);
        debug_struct.field("ops_insights_status", &self.ops_insights_status);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DatabaseProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DatabaseProperties");
        debug_struct.field("state", &self.state);
        debug_struct.field("db_version", &self.db_version);
        debug_struct.field("db_backup_config", &self.db_backup_config);
        debug_struct.field(
            "database_management_config",
            &self.database_management_config,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbBackupConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbBackupConfig");
        debug_struct.field("auto_backup_enabled", &self.auto_backup_enabled);
        debug_struct.field(
            "backup_destination_details",
            &self.backup_destination_details,
        );
        debug_struct.field("retention_period_days", &self.retention_period_days);
        debug_struct.field("backup_deletion_policy", &self.backup_deletion_policy);
        debug_struct.field("auto_full_backup_day", &self.auto_full_backup_day);
        debug_struct.field("auto_full_backup_window", &self.auto_full_backup_window);
        debug_struct.field(
            "auto_incremental_backup_window",
            &self.auto_incremental_backup_window,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::db_backup_config::BackupDestinationDetails {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BackupDestinationDetails");
        debug_struct.field("r#type", &self.r#type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GetDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetDatabaseRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDatabasesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDatabasesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDatabasesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDatabasesResponse");
        debug_struct.field("databases", &self.databases);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DatabaseCharacterSet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DatabaseCharacterSet");
        debug_struct.field("name", &self.name);
        debug_struct.field("character_set_type", &self.character_set_type);
        debug_struct.field("character_set", &self.character_set);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDatabaseCharacterSetsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDatabaseCharacterSetsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDatabaseCharacterSetsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDatabaseCharacterSetsResponse");
        debug_struct.field("database_character_sets", &self.database_character_sets);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbNode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbNode");
        debug_struct.field("name", &self.name);
        debug_struct.field("properties", &self.properties);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbNodeProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbNodeProperties");
        debug_struct.field("ocid", &self.ocid);
        debug_struct.field("ocpu_count", &self.ocpu_count);
        debug_struct.field("memory_size_gb", &self.memory_size_gb);
        debug_struct.field("db_node_storage_size_gb", &self.db_node_storage_size_gb);
        debug_struct.field("db_server_ocid", &self.db_server_ocid);
        debug_struct.field("hostname", &self.hostname);
        debug_struct.field("state", &self.state);
        debug_struct.field("total_cpu_core_count", &self.total_cpu_core_count);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbServer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbServer");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("properties", &self.properties);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbServerProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbServerProperties");
        debug_struct.field("ocid", &self.ocid);
        debug_struct.field("ocpu_count", &self.ocpu_count);
        debug_struct.field("max_ocpu_count", &self.max_ocpu_count);
        debug_struct.field("memory_size_gb", &self.memory_size_gb);
        debug_struct.field("max_memory_size_gb", &self.max_memory_size_gb);
        debug_struct.field("db_node_storage_size_gb", &self.db_node_storage_size_gb);
        debug_struct.field(
            "max_db_node_storage_size_gb",
            &self.max_db_node_storage_size_gb,
        );
        debug_struct.field("vm_count", &self.vm_count);
        debug_struct.field("state", &self.state);
        debug_struct.field("db_node_ids", &self.db_node_ids);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbSystem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbSystem");
        debug_struct.field("name", &self.name);
        debug_struct.field("properties", &self.properties);
        debug_struct.field("gcp_oracle_zone", &self.gcp_oracle_zone);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("odb_network", &self.odb_network);
        debug_struct.field("odb_subnet", &self.odb_subnet);
        debug_struct.field("entitlement_id", &self.entitlement_id);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("oci_url", &self.oci_url);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbSystemProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbSystemProperties");
        debug_struct.field("shape", &self.shape);
        debug_struct.field("compute_count", &self.compute_count);
        debug_struct.field(
            "initial_data_storage_size_gb",
            &self.initial_data_storage_size_gb,
        );
        debug_struct.field("database_edition", &self.database_edition);
        debug_struct.field("license_model", &self.license_model);
        debug_struct.field("ssh_public_keys", &self.ssh_public_keys);
        debug_struct.field("hostname_prefix", &self.hostname_prefix);
        debug_struct.field("hostname", &self.hostname);
        debug_struct.field("private_ip", &self.private_ip);
        debug_struct.field("data_collection_options", &self.data_collection_options);
        debug_struct.field("time_zone", &self.time_zone);
        debug_struct.field("lifecycle_state", &self.lifecycle_state);
        debug_struct.field("db_home", &self.db_home);
        debug_struct.field("ocid", &self.ocid);
        debug_struct.field("memory_size_gb", &self.memory_size_gb);
        debug_struct.field("compute_model", &self.compute_model);
        debug_struct.field("data_storage_size_gb", &self.data_storage_size_gb);
        debug_struct.field("reco_storage_size_gb", &self.reco_storage_size_gb);
        debug_struct.field("domain", &self.domain);
        debug_struct.field("node_count", &self.node_count);
        debug_struct.field("db_system_options", &self.db_system_options);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DataCollectionOptionsDbSystem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataCollectionOptionsDbSystem");
        debug_struct.field(
            "is_diagnostics_events_enabled",
            &self.is_diagnostics_events_enabled,
        );
        debug_struct.field("is_incident_logs_enabled", &self.is_incident_logs_enabled);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbSystemOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbSystemOptions");
        debug_struct.field("storage_management", &self.storage_management);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbHome {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbHome");
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("db_version", &self.db_version);
        debug_struct.field("database", &self.database);
        debug_struct.field(
            "is_unified_auditing_enabled",
            &self.is_unified_auditing_enabled,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CreateDbSystemRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDbSystemRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("db_system_id", &self.db_system_id);
        debug_struct.field("db_system", &self.db_system);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DeleteDbSystemRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteDbSystemRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GetDbSystemRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetDbSystemRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbSystemsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbSystemsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbSystemsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbSystemsResponse");
        debug_struct.field("db_systems", &self.db_systems);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbSystemInitialStorageSize {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbSystemInitialStorageSize");
        debug_struct.field("name", &self.name);
        debug_struct.field("properties", &self.properties);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbSystemInitialStorageSizeProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbSystemInitialStorageSizeProperties");
        debug_struct.field("storage_management", &self.storage_management);
        debug_struct.field("shape_type", &self.shape_type);
        debug_struct.field("storage_size_details", &self.storage_size_details);
        debug_struct.field(
            "launch_from_backup_storage_size_details",
            &self.launch_from_backup_storage_size_details,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::StorageSizeDetails {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StorageSizeDetails");
        debug_struct.field("data_storage_size_in_gbs", &self.data_storage_size_in_gbs);
        debug_struct.field("reco_storage_size_in_gbs", &self.reco_storage_size_in_gbs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbSystemInitialStorageSizesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbSystemInitialStorageSizesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbSystemInitialStorageSizesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbSystemInitialStorageSizesResponse");
        debug_struct.field(
            "db_system_initial_storage_sizes",
            &self.db_system_initial_storage_sizes,
        );
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbSystemShape {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbSystemShape");
        debug_struct.field("name", &self.name);
        debug_struct.field("shape", &self.shape);
        debug_struct.field("min_node_count", &self.min_node_count);
        debug_struct.field("max_node_count", &self.max_node_count);
        debug_struct.field("min_storage_count", &self.min_storage_count);
        debug_struct.field("max_storage_count", &self.max_storage_count);
        debug_struct.field(
            "available_core_count_per_node",
            &self.available_core_count_per_node,
        );
        debug_struct.field(
            "available_memory_per_node_gb",
            &self.available_memory_per_node_gb,
        );
        debug_struct.field("available_data_storage_tb", &self.available_data_storage_tb);
        debug_struct.field("min_core_count_per_node", &self.min_core_count_per_node);
        debug_struct.field("min_memory_per_node_gb", &self.min_memory_per_node_gb);
        debug_struct.field(
            "min_db_node_storage_per_node_gb",
            &self.min_db_node_storage_per_node_gb,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbVersion");
        debug_struct.field("name", &self.name);
        debug_struct.field("properties", &self.properties);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DbVersionProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DbVersionProperties");
        debug_struct.field("version", &self.version);
        debug_struct.field(
            "is_latest_for_major_version",
            &self.is_latest_for_major_version,
        );
        debug_struct.field("supports_pdb", &self.supports_pdb);
        debug_struct.field("is_preview_db_version", &self.is_preview_db_version);
        debug_struct.field("is_upgrade_supported", &self.is_upgrade_supported);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbVersionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbVersionsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbVersionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbVersionsResponse");
        debug_struct.field("db_versions", &self.db_versions);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Entitlement {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Entitlement");
        debug_struct.field("name", &self.name);
        debug_struct.field("cloud_account_details", &self.cloud_account_details);
        debug_struct.field("entitlement_id", &self.entitlement_id);
        debug_struct.field("state", &self.state);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CloudAccountDetails {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CloudAccountDetails");
        debug_struct.field("cloud_account", &self.cloud_account);
        debug_struct.field("cloud_account_home_region", &self.cloud_account_home_region);
        debug_struct.field("link_existing_account_uri", &self.link_existing_account_uri);
        debug_struct.field("account_creation_uri", &self.account_creation_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CloudExadataInfrastructure {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CloudExadataInfrastructure");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("gcp_oracle_zone", &self.gcp_oracle_zone);
        debug_struct.field("entitlement_id", &self.entitlement_id);
        debug_struct.field("properties", &self.properties);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CloudExadataInfrastructureProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CloudExadataInfrastructureProperties");
        debug_struct.field("ocid", &self.ocid);
        debug_struct.field("compute_count", &self.compute_count);
        debug_struct.field("storage_count", &self.storage_count);
        debug_struct.field("total_storage_size_gb", &self.total_storage_size_gb);
        debug_struct.field("available_storage_size_gb", &self.available_storage_size_gb);
        debug_struct.field("maintenance_window", &self.maintenance_window);
        debug_struct.field("state", &self.state);
        debug_struct.field("shape", &self.shape);
        debug_struct.field("oci_url", &self.oci_url);
        debug_struct.field("cpu_count", &self.cpu_count);
        debug_struct.field("max_cpu_count", &self.max_cpu_count);
        debug_struct.field("memory_size_gb", &self.memory_size_gb);
        debug_struct.field("max_memory_gb", &self.max_memory_gb);
        debug_struct.field("db_node_storage_size_gb", &self.db_node_storage_size_gb);
        debug_struct.field(
            "max_db_node_storage_size_gb",
            &self.max_db_node_storage_size_gb,
        );
        debug_struct.field("data_storage_size_tb", &self.data_storage_size_tb);
        debug_struct.field("max_data_storage_tb", &self.max_data_storage_tb);
        debug_struct.field("activated_storage_count", &self.activated_storage_count);
        debug_struct.field("additional_storage_count", &self.additional_storage_count);
        debug_struct.field("db_server_version", &self.db_server_version);
        debug_struct.field("storage_server_version", &self.storage_server_version);
        debug_struct.field("next_maintenance_run_id", &self.next_maintenance_run_id);
        debug_struct.field("next_maintenance_run_time", &self.next_maintenance_run_time);
        debug_struct.field(
            "next_security_maintenance_run_time",
            &self.next_security_maintenance_run_time,
        );
        debug_struct.field("customer_contacts", &self.customer_contacts);
        debug_struct.field(
            "monthly_storage_server_version",
            &self.monthly_storage_server_version,
        );
        debug_struct.field("monthly_db_server_version", &self.monthly_db_server_version);
        debug_struct.field("compute_model", &self.compute_model);
        debug_struct.field("database_server_type", &self.database_server_type);
        debug_struct.field("storage_server_type", &self.storage_server_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::MaintenanceWindow {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MaintenanceWindow");
        debug_struct.field("preference", &self.preference);
        debug_struct.field("months", &self.months);
        debug_struct.field("weeks_of_month", &self.weeks_of_month);
        debug_struct.field("days_of_week", &self.days_of_week);
        debug_struct.field("hours_of_day", &self.hours_of_day);
        debug_struct.field("lead_time_week", &self.lead_time_week);
        debug_struct.field("patching_mode", &self.patching_mode);
        debug_struct.field(
            "custom_action_timeout_mins",
            &self.custom_action_timeout_mins,
        );
        debug_struct.field(
            "is_custom_action_timeout_enabled",
            &self.is_custom_action_timeout_enabled,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ExadbVmCluster {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExadbVmCluster");
        debug_struct.field("name", &self.name);
        debug_struct.field("properties", &self.properties);
        debug_struct.field("gcp_oracle_zone", &self.gcp_oracle_zone);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("odb_network", &self.odb_network);
        debug_struct.field("odb_subnet", &self.odb_subnet);
        debug_struct.field("backup_odb_subnet", &self.backup_odb_subnet);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("entitlement_id", &self.entitlement_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ExadbVmClusterStorageDetails {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExadbVmClusterStorageDetails");
        debug_struct.field("size_in_gbs_per_node", &self.size_in_gbs_per_node);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ExadbVmClusterProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExadbVmClusterProperties");
        debug_struct.field("cluster_name", &self.cluster_name);
        debug_struct.field("grid_image_id", &self.grid_image_id);
        debug_struct.field("node_count", &self.node_count);
        debug_struct.field(
            "enabled_ecpu_count_per_node",
            &self.enabled_ecpu_count_per_node,
        );
        debug_struct.field(
            "additional_ecpu_count_per_node",
            &self.additional_ecpu_count_per_node,
        );
        debug_struct.field("vm_file_system_storage", &self.vm_file_system_storage);
        debug_struct.field("license_model", &self.license_model);
        debug_struct.field("exascale_db_storage_vault", &self.exascale_db_storage_vault);
        debug_struct.field("hostname_prefix", &self.hostname_prefix);
        debug_struct.field("hostname", &self.hostname);
        debug_struct.field("ssh_public_keys", &self.ssh_public_keys);
        debug_struct.field("data_collection_options", &self.data_collection_options);
        debug_struct.field("time_zone", &self.time_zone);
        debug_struct.field("lifecycle_state", &self.lifecycle_state);
        debug_struct.field("shape_attribute", &self.shape_attribute);
        debug_struct.field("memory_size_gb", &self.memory_size_gb);
        debug_struct.field("scan_listener_port_tcp", &self.scan_listener_port_tcp);
        debug_struct.field("oci_uri", &self.oci_uri);
        debug_struct.field("gi_version", &self.gi_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ExascaleDbStorageVault {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExascaleDbStorageVault");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("gcp_oracle_zone", &self.gcp_oracle_zone);
        debug_struct.field("properties", &self.properties);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("entitlement_id", &self.entitlement_id);
        debug_struct.field("labels", &self.labels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ExascaleDbStorageVaultProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExascaleDbStorageVaultProperties");
        debug_struct.field("ocid", &self.ocid);
        debug_struct.field("time_zone", &self.time_zone);
        debug_struct.field(
            "exascale_db_storage_details",
            &self.exascale_db_storage_details,
        );
        debug_struct.field("state", &self.state);
        debug_struct.field("description", &self.description);
        debug_struct.field("vm_cluster_ids", &self.vm_cluster_ids);
        debug_struct.field("vm_cluster_count", &self.vm_cluster_count);
        debug_struct.field(
            "additional_flash_cache_percent",
            &self.additional_flash_cache_percent,
        );
        debug_struct.field("oci_uri", &self.oci_uri);
        debug_struct.field("attached_shape_attributes", &self.attached_shape_attributes);
        debug_struct.field(
            "available_shape_attributes",
            &self.available_shape_attributes,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ExascaleDbStorageDetails {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExascaleDbStorageDetails");
        debug_struct.field("available_size_gbs", &self.available_size_gbs);
        debug_struct.field("total_size_gbs", &self.total_size_gbs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GetExascaleDbStorageVaultRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetExascaleDbStorageVaultRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListExascaleDbStorageVaultsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListExascaleDbStorageVaultsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListExascaleDbStorageVaultsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListExascaleDbStorageVaultsResponse");
        debug_struct.field(
            "exascale_db_storage_vaults",
            &self.exascale_db_storage_vaults,
        );
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CreateExascaleDbStorageVaultRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateExascaleDbStorageVaultRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field(
            "exascale_db_storage_vault_id",
            &self.exascale_db_storage_vault_id,
        );
        debug_struct.field("exascale_db_storage_vault", &self.exascale_db_storage_vault);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DeleteExascaleDbStorageVaultRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteExascaleDbStorageVaultRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GiVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GiVersion");
        debug_struct.field("name", &self.name);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::LocationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LocationMetadata");
        debug_struct.field("gcp_oracle_zones", &self.gcp_oracle_zones);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::MinorVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MinorVersion");
        debug_struct.field("name", &self.name);
        debug_struct.field("grid_image_id", &self.grid_image_id);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListMinorVersionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListMinorVersionsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListMinorVersionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListMinorVersionsResponse");
        debug_struct.field("minor_versions", &self.minor_versions);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::OdbNetwork {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OdbNetwork");
        debug_struct.field("name", &self.name);
        debug_struct.field("network", &self.network);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("state", &self.state);
        debug_struct.field("entitlement_id", &self.entitlement_id);
        debug_struct.field("gcp_oracle_zone", &self.gcp_oracle_zone);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CreateOdbNetworkRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateOdbNetworkRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("odb_network_id", &self.odb_network_id);
        debug_struct.field("odb_network", &self.odb_network);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DeleteOdbNetworkRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteOdbNetworkRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListOdbNetworksRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListOdbNetworksRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListOdbNetworksResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListOdbNetworksResponse");
        debug_struct.field("odb_networks", &self.odb_networks);
        debug_struct.field("next_page_token", &self.next_page_token);
        debug_struct.field("unreachable", &self.unreachable);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GetOdbNetworkRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetOdbNetworkRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::OdbSubnet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OdbSubnet");
        debug_struct.field("name", &self.name);
        debug_struct.field("cidr_range", &self.cidr_range);
        debug_struct.field("purpose", &self.purpose);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("state", &self.state);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CreateOdbSubnetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateOdbSubnetRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("odb_subnet_id", &self.odb_subnet_id);
        debug_struct.field("odb_subnet", &self.odb_subnet);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DeleteOdbSubnetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteOdbSubnetRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListOdbSubnetsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListOdbSubnetsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListOdbSubnetsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListOdbSubnetsResponse");
        debug_struct.field("odb_subnets", &self.odb_subnets);
        debug_struct.field("next_page_token", &self.next_page_token);
        debug_struct.field("unreachable", &self.unreachable);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GetOdbSubnetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetOdbSubnetRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListCloudExadataInfrastructuresRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCloudExadataInfrastructuresRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListCloudExadataInfrastructuresResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCloudExadataInfrastructuresResponse");
        debug_struct.field(
            "cloud_exadata_infrastructures",
            &self.cloud_exadata_infrastructures,
        );
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GetCloudExadataInfrastructureRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetCloudExadataInfrastructureRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CreateCloudExadataInfrastructureRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateCloudExadataInfrastructureRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field(
            "cloud_exadata_infrastructure_id",
            &self.cloud_exadata_infrastructure_id,
        );
        debug_struct.field(
            "cloud_exadata_infrastructure",
            &self.cloud_exadata_infrastructure,
        );
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DeleteCloudExadataInfrastructureRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteCloudExadataInfrastructureRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("request_id", &self.request_id);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListCloudVmClustersRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCloudVmClustersRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListCloudVmClustersResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCloudVmClustersResponse");
        debug_struct.field("cloud_vm_clusters", &self.cloud_vm_clusters);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GetCloudVmClusterRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetCloudVmClusterRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CreateCloudVmClusterRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateCloudVmClusterRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("cloud_vm_cluster_id", &self.cloud_vm_cluster_id);
        debug_struct.field("cloud_vm_cluster", &self.cloud_vm_cluster);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DeleteCloudVmClusterRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteCloudVmClusterRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("request_id", &self.request_id);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListEntitlementsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEntitlementsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListEntitlementsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEntitlementsResponse");
        debug_struct.field("entitlements", &self.entitlements);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbServersRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbServersRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbServersResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbServersResponse");
        debug_struct.field("db_servers", &self.db_servers);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbNodesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbNodesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbNodesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbNodesResponse");
        debug_struct.field("db_nodes", &self.db_nodes);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListGiVersionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListGiVersionsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListGiVersionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListGiVersionsResponse");
        debug_struct.field("gi_versions", &self.gi_versions);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbSystemShapesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbSystemShapesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListDbSystemShapesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDbSystemShapesResponse");
        debug_struct.field("db_system_shapes", &self.db_system_shapes);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::OperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OperationMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("target", &self.target);
        debug_struct.field("verb", &self.verb);
        debug_struct.field("status_message", &self.status_message);
        debug_struct.field("requested_cancellation", &self.requested_cancellation);
        debug_struct.field("api_version", &self.api_version);
        debug_struct.field("percent_complete", &self.percent_complete);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListAutonomousDatabasesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAutonomousDatabasesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListAutonomousDatabasesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAutonomousDatabasesResponse");
        debug_struct.field("autonomous_databases", &self.autonomous_databases);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GetAutonomousDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetAutonomousDatabaseRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CreateAutonomousDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateAutonomousDatabaseRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("autonomous_database_id", &self.autonomous_database_id);
        debug_struct.field("autonomous_database", &self.autonomous_database);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::UpdateAutonomousDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateAutonomousDatabaseRequest");
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("autonomous_database", &self.autonomous_database);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DeleteAutonomousDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteAutonomousDatabaseRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::RestoreAutonomousDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RestoreAutonomousDatabaseRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("restore_time", &self.restore_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::StopAutonomousDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StopAutonomousDatabaseRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::StartAutonomousDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StartAutonomousDatabaseRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::RestartAutonomousDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RestartAutonomousDatabaseRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::SwitchoverAutonomousDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SwitchoverAutonomousDatabaseRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("peer_autonomous_database", &self.peer_autonomous_database);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::FailoverAutonomousDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FailoverAutonomousDatabaseRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("peer_autonomous_database", &self.peer_autonomous_database);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GenerateAutonomousDatabaseWalletRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateAutonomousDatabaseWalletRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("is_regional", &self.is_regional);
        debug_struct.field("password", &self.password);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GenerateAutonomousDatabaseWalletResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateAutonomousDatabaseWalletResponse");
        debug_struct.field("archive_content", &self.archive_content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListAutonomousDbVersionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAutonomousDbVersionsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListAutonomousDbVersionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAutonomousDbVersionsResponse");
        debug_struct.field("autonomous_db_versions", &self.autonomous_db_versions);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListAutonomousDatabaseCharacterSetsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAutonomousDatabaseCharacterSetsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListAutonomousDatabaseCharacterSetsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAutonomousDatabaseCharacterSetsResponse");
        debug_struct.field(
            "autonomous_database_character_sets",
            &self.autonomous_database_character_sets,
        );
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListAutonomousDatabaseBackupsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAutonomousDatabaseBackupsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListAutonomousDatabaseBackupsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAutonomousDatabaseBackupsResponse");
        debug_struct.field(
            "autonomous_database_backups",
            &self.autonomous_database_backups,
        );
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CreateExadbVmClusterRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateExadbVmClusterRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("exadb_vm_cluster_id", &self.exadb_vm_cluster_id);
        debug_struct.field("exadb_vm_cluster", &self.exadb_vm_cluster);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DeleteExadbVmClusterRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteExadbVmClusterRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GetExadbVmClusterRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetExadbVmClusterRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListExadbVmClustersRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListExadbVmClustersRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListExadbVmClustersResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListExadbVmClustersResponse");
        debug_struct.field("exadb_vm_clusters", &self.exadb_vm_clusters);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::UpdateExadbVmClusterRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateExadbVmClusterRequest");
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("exadb_vm_cluster", &self.exadb_vm_cluster);
        debug_struct.field("request_id", &self.request_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::RemoveVirtualMachineExadbVmClusterRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RemoveVirtualMachineExadbVmClusterRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("request_id", &self.request_id);
        debug_struct.field("hostnames", &self.hostnames);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PluggableDatabase {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PluggableDatabase");
        debug_struct.field("name", &self.name);
        debug_struct.field("properties", &self.properties);
        debug_struct.field("oci_url", &self.oci_url);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PluggableDatabaseProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PluggableDatabaseProperties");
        debug_struct.field("compartment_id", &self.compartment_id);
        debug_struct.field("connection_strings", &self.connection_strings);
        debug_struct.field("container_database_ocid", &self.container_database_ocid);
        debug_struct.field("defined_tags", &self.defined_tags);
        debug_struct.field("freeform_tags", &self.freeform_tags);
        debug_struct.field("ocid", &self.ocid);
        debug_struct.field("is_restricted", &self.is_restricted);
        debug_struct.field("lifecycle_details", &self.lifecycle_details);
        debug_struct.field("lifecycle_state", &self.lifecycle_state);
        debug_struct.field("pdb_name", &self.pdb_name);
        debug_struct.field("pdb_node_level_details", &self.pdb_node_level_details);
        debug_struct.field(
            "database_management_config",
            &self.database_management_config,
        );
        debug_struct.field("operations_insights_state", &self.operations_insights_state);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::pluggable_database_properties::DefinedTagValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DefinedTagValue");
        debug_struct.field("tags", &self.tags);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PluggableDatabaseConnectionStrings {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PluggableDatabaseConnectionStrings");
        debug_struct.field("all_connection_strings", &self.all_connection_strings);
        debug_struct.field("pdb_default", &self.pdb_default);
        debug_struct.field("pdb_ip_default", &self.pdb_ip_default);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PluggableDatabaseNodeLevelDetails {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PluggableDatabaseNodeLevelDetails");
        debug_struct.field("node_name", &self.node_name);
        debug_struct.field("open_mode", &self.open_mode);
        debug_struct.field("pluggable_database_id", &self.pluggable_database_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DatabaseManagementConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DatabaseManagementConfig");
        debug_struct.field("management_state", &self.management_state);
        debug_struct.field("management_type", &self.management_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GetPluggableDatabaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetPluggableDatabaseRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListPluggableDatabasesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListPluggableDatabasesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ListPluggableDatabasesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListPluggableDatabasesResponse");
        debug_struct.field("pluggable_databases", &self.pluggable_databases);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CloudVmCluster {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CloudVmCluster");
        debug_struct.field("name", &self.name);
        debug_struct.field("exadata_infrastructure", &self.exadata_infrastructure);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("properties", &self.properties);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("cidr", &self.cidr);
        debug_struct.field("backup_subnet_cidr", &self.backup_subnet_cidr);
        debug_struct.field("network", &self.network);
        debug_struct.field("gcp_oracle_zone", &self.gcp_oracle_zone);
        debug_struct.field("odb_network", &self.odb_network);
        debug_struct.field("odb_subnet", &self.odb_subnet);
        debug_struct.field("backup_odb_subnet", &self.backup_odb_subnet);
        debug_struct.field("identity_connector", &self.identity_connector);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::CloudVmClusterProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CloudVmClusterProperties");
        debug_struct.field("ocid", &self.ocid);
        debug_struct.field("license_type", &self.license_type);
        debug_struct.field("gi_version", &self.gi_version);
        debug_struct.field("time_zone", &self.time_zone);
        debug_struct.field("ssh_public_keys", &self.ssh_public_keys);
        debug_struct.field("node_count", &self.node_count);
        debug_struct.field("shape", &self.shape);
        debug_struct.field("ocpu_count", &self.ocpu_count);
        debug_struct.field("memory_size_gb", &self.memory_size_gb);
        debug_struct.field("db_node_storage_size_gb", &self.db_node_storage_size_gb);
        debug_struct.field("storage_size_gb", &self.storage_size_gb);
        debug_struct.field("data_storage_size_tb", &self.data_storage_size_tb);
        debug_struct.field("disk_redundancy", &self.disk_redundancy);
        debug_struct.field("sparse_diskgroup_enabled", &self.sparse_diskgroup_enabled);
        debug_struct.field("local_backup_enabled", &self.local_backup_enabled);
        debug_struct.field("hostname_prefix", &self.hostname_prefix);
        debug_struct.field(
            "diagnostics_data_collection_options",
            &self.diagnostics_data_collection_options,
        );
        debug_struct.field("state", &self.state);
        debug_struct.field("scan_listener_port_tcp", &self.scan_listener_port_tcp);
        debug_struct.field(
            "scan_listener_port_tcp_ssl",
            &self.scan_listener_port_tcp_ssl,
        );
        debug_struct.field("domain", &self.domain);
        debug_struct.field("scan_dns", &self.scan_dns);
        debug_struct.field("hostname", &self.hostname);
        debug_struct.field("cpu_core_count", &self.cpu_core_count);
        debug_struct.field("system_version", &self.system_version);
        debug_struct.field("scan_ip_ids", &self.scan_ip_ids);
        debug_struct.field("scan_dns_record_id", &self.scan_dns_record_id);
        debug_struct.field("oci_url", &self.oci_url);
        debug_struct.field("db_server_ocids", &self.db_server_ocids);
        debug_struct.field("compartment_id", &self.compartment_id);
        debug_struct.field("dns_listener_ip", &self.dns_listener_ip);
        debug_struct.field("cluster_name", &self.cluster_name);
        debug_struct.field("compute_model", &self.compute_model);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DataCollectionOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataCollectionOptions");
        debug_struct.field(
            "diagnostics_events_enabled",
            &self.diagnostics_events_enabled,
        );
        debug_struct.field("health_monitoring_enabled", &self.health_monitoring_enabled);
        debug_struct.field("incident_logs_enabled", &self.incident_logs_enabled);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}
